Raising an error during operator overloads:
What we have agreed upon.

Operator overloads do not return an error, but we must somehow deal with the 
errors that are generated.

Each object is to have an instance variable:

	Err		*i_operator_err;		//	ptr to single global variable in front end
									//	all objects point to same one

also, during the initializer method must pass in the address of the global
variable the holds the operator error code.

	Err		IFooType(Err *operator_error, ...);

Every operator overload method must have a corresponding "normal" procedure 
call that performs the operation, and returns an error.  Then, inside the
operator overload method, only perform the operation if there has been no
error.

Err				CFooType::Operator_ADD(CFooType *foo, CBarType *bar, CBazType *baz)
{
	Err		err = Err_NONE;
	
	// perform error-prone operation
	//	report the error if you get it, like normal
	
	return err;
}

CBazType		*CFooType::operator+(CFooType *foo, CBarType *bar)
{
	CBazType	*baz;
	
	if (!(*i_operator_err)) {
		*i_operator_err = Operator_ADD(foo, bar, baz);
	}
}

===========================================
in the front end is this support code:

	Err		g_operator_error;
	
	Err		GetAndClearError(void)
	{
		Err		err = g_operator_error;
		
		g_operator_error = Err_NONE;
		
		return err;
	}
	
	#define		FOE()	\
		FCE(GetAndClearOperatorError());

===========================================
Now, the front end code can do this:

{
	FCE(Operator_ADD(foo, bar, baz));
}

or this:

{
	baz = foo + bar;
	FOE();
}

you can have multiple operators in a line and the first error will
abort the rest of the statement.

